// 《围棋》作者版权所有。保留所有权利。
// 此源代码的使用受BSD样式
// 许可证的约束，该许可证可以在许可证文件中找到。

package modload

import (
	"bytes"
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"go/build"
	"internal/lazyregexp"
	"io/ioutil"
	"os"
	"path"
	"path/filepath"
	"strconv"
	"strings"
	"sync"

	"cmd/go/internal/base"
	"cmd/go/internal/cfg"
	"cmd/go/internal/fsys"
	"cmd/go/internal/lockedfile"
	"cmd/go/internal/modconv"
	"cmd/go/internal/modfetch"
	"cmd/go/internal/search"

	"golang.org/x/mod/modfile"
	"golang.org/x/mod/module"
	"golang.org/x/mod/semver"
)

// 由其他软件包设置的变量。
// 
// TODO（#40775）：看看这些参数是否可以作为显式参数进行探测。
var (
	// RootMode决定是否需要模块根目录。
	RootMode Root

	// ForceUseModules可设置为在
	// GO111MODULE=auto时强制启用模块，或在GO111MODULE=off时报告错误。
	ForceUseModules bool

	allowMissingModuleImports bool

	// EXPLICITWRITEGMODE阻止加载包、列表模块和其他函数
	// 更新go。mod和go。需要更新时汇总或报告错误
	// 。如果包会导致go，则应设置此选项。mod to write 
	// 多次（例如，“go get”多次调用LoadPackages）或
	// 如果在go之前需要其他操作才能成功。mod和go。sum 
	// 可以写入（例如，“go mod download”必须在
	// 向go.sum添加sum之前下载模块）。设置此选项的包负责显式调用
	// WriteGoMod。
	ExplicitWriteGoMod bool
)

// 初始化中设置的变量。
var (
	initialized bool

	// 这些主要用于初始化主模块，应该是
	// 最终被它们取代，但在需要模块
	// 根但尚未初始化主模块的情况下仍然使用。设置为
	// 主模块的modroot。
	// modRoots！=nil表示len（modRoots）>0 
	modRoots []string
	gopath   string
)

// EnterModule重置main模块和需求，以仅引用这一个模块。
func EnterModule(ctx context.Context, enterModroot string) {
	MainModules = nil // 重置主模块
	requirements = nil
	workFilePath = "" // 强制模块模式
	modfetch.Reset()

	modRoots = []string{enterModroot}
	LoadModFile(ctx)
}

// 在初始化工作文件中设置变量
var (
	// 设置为go的路径。工作文件，如果工作区模式被禁用，则为“”。
	workFilePath string
)

type MainModuleSet struct {
	// 版本是模块。每个主要模块的版本值。
	// 对于它们中的每一个，路径字段是普通模块路径，版本
	// 字段是空字符串。
	versions []module.Version

	// modRoot将版本中的每个模块映射到其绝对文件系统路径。
	modRoot map[module.Version]string

	// pathPrefix是模块中包的路径前缀，后面没有一个
	// slash。对于大多数模块，pathPrefix只是一个版本。路径，但
	// 标准库模块“std”的前缀为空。
	pathPrefix map[module.Version]string

	// ingootsrc缓存modRoot是否在GOROOT/src中。
	// “std”模块在GOROOT/src中是特殊的，但在其他方面则不是。
	inGorootSrc map[module.Version]bool

	modFiles map[module.Version]*modfile.File

	modContainingCWD module.Version

	workFileGoVersion string

	workFileReplaceMap map[module.Version]module.Version
	// 每个模块路径的最高替换版本；仅用于通配符替换的空字符串
	highestReplaced map[string]string

	indexMu sync.Mutex
	indices map[module.Version]*modFileIndex
}

func (mms *MainModuleSet) PathPrefix(m module.Version) string {
	return mms.pathPrefix[m]
}

// Versions返回模块。每个主要模块的版本值。
// 对于它们中的每一个，路径字段是普通模块路径，版本
// 字段是空字符串。
// 调用方不应修改返回的切片。
func (mms *MainModuleSet) Versions() []module.Version {
	if mms == nil {
		return nil
	}
	return mms.versions
}

func (mms *MainModuleSet) Contains(path string) bool {
	if mms == nil {
		return false
	}
	for _, v := range mms.versions {
		if v.Path == path {
			return true
		}
	}
	return false
}

func (mms *MainModuleSet) ModRoot(m module.Version) string {
	if mms == nil {
		return ""
	}
	return mms.modRoot[m]
}

func (mms *MainModuleSet) InGorootSrc(m module.Version) bool {
	if mms == nil {
		return false
	}
	return mms.inGorootSrc[m]
}

func (mms *MainModuleSet) mustGetSingleMainModule() module.Version {
	if mms == nil || len(mms.versions) == 0 {
		panic("internal error: mustGetSingleMainModule called in context with no main modules")
	}
	if len(mms.versions) != 1 {
		if inWorkspaceMode() {
			panic("internal error: mustGetSingleMainModule called in workspace mode")
		} else {
			panic("internal error: multiple main modules present outside of workspace mode")
		}
	}
	return mms.versions[0]
}

func (mms *MainModuleSet) GetSingleIndexOrNil() *modFileIndex {
	if mms == nil {
		return nil
	}
	if len(mms.versions) == 0 {
		return nil
	}
	return mms.indices[mms.mustGetSingleMainModule()]
}

func (mms *MainModuleSet) Index(m module.Version) *modFileIndex {
	mms.indexMu.Lock()
	defer mms.indexMu.Unlock()
	return mms.indices[m]
}

func (mms *MainModuleSet) SetIndex(m module.Version, index *modFileIndex) {
	mms.indexMu.Lock()
	defer mms.indexMu.Unlock()
	mms.indices[m] = index
}

func (mms *MainModuleSet) ModFile(m module.Version) *modfile.File {
	return mms.modFiles[m]
}

func (mms *MainModuleSet) Len() int {
	if mms == nil {
		return 0
	}
	return len(mms.versions)
}

// ModContainingCWD返回包含工作目录的主模块
// or module。版本{}如果主模块都不包含工作的
// 目录。
func (mms *MainModuleSet) ModContainingCWD() module.Version {
	return mms.modContainingCWD
}

func (mms *MainModuleSet) HighestReplaced() map[string]string {
	return mms.highestReplaced
}

// GoVersion返回单个模块上设置的go版本，在模块模式下，
// 或go。工作区模式下的工作文件。
func (mms *MainModuleSet) GoVersion() string {
	if !inWorkspaceMode() {
		return modFileGoVersion(mms.ModFile(mms.mustGetSingleMainModule()))
	}
	v := mms.workFileGoVersion
	if v == "" {
		// 回到1.18开始。工作文件。
		v = "1.18"
	}
	return v
}

func (mms *MainModuleSet) WorkFileReplaceMap() map[module.Version]module.Version {
	return mms.workFileReplaceMap
}

var MainModules *MainModuleSet

type Root int

const (
	// AutoRoot是大多数命令的默认值。modload。Init将寻找
	// 一次成功。当前目录或任何父目录中的mod文件。如果没有找到，
	// 模块可能会被禁用（GO111MODULE=auto），或者命令可能会在
	// 受限模块模式下运行。
	AutoRoot Root = iota

	// NoRoot用于在模块模式下运行并忽略任何go的命令。mod 
	// 将当前目录或父目录归档。
	NoRoot

	// NeedRoot用于必须在模块模式下运行且没有主模块时没有意义的命令。
	NeedRoot
)

// ModFile返回解析后的go。mod文件。
// 
// 请注意，在调用LoadPackages或LoadModGraph后，
// modfile中的require语句。文件不再是真相的来源，将被忽略：直接进行的编辑将在下次调用WriteGoMod时丢失。
// 对go中的require语句进行永久性更改。mod，在加载前编辑它。
func ModFile() *modfile.File {
	Init()
	modFile := MainModules.ModFile(MainModules.mustGetSingleMainModule())
	if modFile == nil {
		die()
	}
	return modFile
}

func BinDir() string {
	Init()
	if cfg.GOBIN != "" {
		return cfg.GOBIN
	}
	if gopath == "" {
		return ""
	}
	return filepath.Join(gopath, "bin")
}

// InitWorkfile为在工作区模式下运行的命令初始化workFilePath变量。其他不在工作区模式下运行的命令
// 例如“go mod tidy”不应调用它。
func InitWorkfile() {
	if RootMode == NoRoot {
		workFilePath = ""
		return
	}

	switch gowork := cfg.Getenv("GOWORK"); gowork {
	case "off":
		workFilePath = ""
	case "", "auto":
		workFilePath = findWorkspaceFile(base.Cwd())
	default:
		if !filepath.IsAbs(gowork) {
			base.Fatalf("the path provided to GOWORK must be an absolute path")
		}
		workFilePath = gowork
	}
}

// WorkFilePath返回go的绝对路径。工作文件，如果不在
// 工作区模式下，则为“”。必须在InitWorkfile之后调用WorkFilePath。
func WorkFilePath() string {
	return workFilePath
}

// Init确定是否启用模块模式，定位当前模块的根目录（如果有），为Git子进程设置环境变量，以及配置cfg、codehost、load、modfetch和search包，以便与模块一起使用
// 。
func Init() {
	if initialized {
		return
	}
	initialized = true

	// 与WillbeeEnabled保持同步。我们在这里进行额外的验证，
	// 有很多诊断和副作用，所以我们不能直接使用
	// 。
	var mustUseModules bool
	env := cfg.Getenv("GO111MODULE")
	switch env {
	default:
		base.Fatalf("go: unknown environment setting GO111MODULE=%s", env)
	case "auto":
		mustUseModules = ForceUseModules
	case "on", "":
		mustUseModules = true
	case "off":
		if ForceUseModules {
			base.Fatalf("go: modules disabled by GO111MODULE=off; see 'go help modules'")
		}
		mustUseModules = false
		return
	}

	if err := fsys.Init(base.Cwd()); err != nil {
		base.Fatalf("go: %v", err)
	}

	// 禁用Git对密码的任何提示。
	// 仅对2.3.0或更高版本有效，但避免使用
	// 在早期版本中的提示太难了。
	// 如果用户已显式设置GIT_TERMINAL_PROMPT=1，则保持
	// 提示。
	// 见戈朗。org/issue/9341和golang。org/issue/12706。
	if os.Getenv("GIT_TERMINAL_PROMPT") == "" {
		os.Setenv("GIT_TERMINAL_PROMPT", "0")
	}

	// 通过Git禁用任何ssh连接池。
	// 如果一个Git子进程将一个子进程转移到后台以缓存一个新连接，
	// 该子进程将保持stdout/stderr打开。Git子进程退出后，
	// os/exec希望能够从stdout/stderr管道读取
	// ，直到EOF获取Git子进程退出前写入的所有数据。
	// 在子进程退出之前，EOF也不会出现，因为子进程
	// 正在控制管道的写入端。
	// 这是不幸的，但它至少出现了两次
	// （见golang.org/issue/13453和golang.org/issue/16104）
	// 并在出现时混淆了用户。
	// 如果用户明确设置了GIT_SSH或GIT_SSH_命令，则
	// 假设他们知道自己在做什么，并且没有踩到它。
	// 但默认为关闭ControlMaster。
	if os.Getenv("GIT_SSH") == "" && os.Getenv("GIT_SSH_COMMAND") == "" {
		os.Setenv("GIT_SSH_COMMAND", "ssh -o ControlMaster=no -o BatchMode=yes")
	}

	if os.Getenv("GCM_INTERACTIVE") == "" {
		os.Setenv("GCM_INTERACTIVE", "never")
	}
	if modRoots != nil {
		// 调用Init之前的modRoot集（“go mod Init”执行此操作）。
		// 无需搜索围棋。摩登派青年
	} else if RootMode == NoRoot {
		if cfg.ModFile != "" && !base.InGOFLAGS("-modfile") {
			base.Fatalf("go: -modfile cannot be used with commands that ignore the current module")
		}
		modRoots = nil
	} else if inWorkspaceMode() {
		// 我们处于工作区模式。
	} else {
		if modRoot := findModuleRoot(base.Cwd()); modRoot == "" {
			if cfg.ModFile != "" {
				base.Fatalf("go: cannot find main module, but -modfile was set.\n\t-modfile cannot be used to set the module root directory.")
			}
			if RootMode == NeedRoot {
				base.Fatalf("go: %v", ErrNoModRoot)
			}
			if !mustUseModules {
				// GO111模块为“自动”，我们找不到模块根目录。
				// 保持GOPATH模式。
				return
			}
		} else if search.InDir(modRoot, os.TempDir()) == "." {
			// 如果创建/tmp/go。mod for experiment，
			// 那么任何在/tmp 
			// 下创建工作目录的测试都会找到它，并在不需要的时候获得模块。
			// 这是一件有点奇怪的事情，但当它发生时，它是相当神秘的。见戈朗。org/issue/26708。
			fmt.Fprintf(os.Stderr, "go: warning: ignoring go.mod in system temp root %v\n", os.TempDir())
			if !mustUseModules {
				return
			}
		} else {
			modRoots = []string{modRoot}
		}
	}
	if cfg.ModFile != "" && !strings.HasSuffix(cfg.ModFile, ".mod") {
		base.Fatalf("go: -modfile=%s: file does not have .mod extension", cfg.ModFile)
	}

	// 我们处于模块模式。设置所有需要设置的全局变量。
	cfg.ModulesEnabled = true
	setDefaultBuildMod()
	list := filepath.SplitList(cfg.BuildContext.GOPATH)
	if len(list) > 0 && list[0] != "" {
		gopath = list[0]
		if _, err := fsys.Stat(filepath.Join(gopath, "go.mod")); err == nil {
			base.Fatalf("$GOPATH/go.mod exists but should not")
		}
	}
}

// WillBeEnabled检查是否应启用模块，但不检查
// 通过安装挂钩初始化模块。如果已经调用了Init，
// WillBeEnabled将返回与Enabled相同的结果。
// 
// 打破一个循环需要此函数。主程序包需要知道是否启用了模块才能安装go get的模块或GOPATH版本，但是Init读取go get中的-modfile标志，所以在安装命令并解析标志之前，不应该调用它。主包可以调用此函数，而不是
// 调用Init并启用。
func WillBeEnabled() bool {
	if modRoots != nil || cfg.ModulesEnabled {
		// 已启用。
		return true
	}
	if initialized {
		// 已初始化，未启用。
		return false
	}

	// 与Init保持同步。Init执行额外的验证并打印警告或
	// 退出，因此它不能直接调用此函数。
	env := cfg.Getenv("GO111MODULE")
	switch env {
	case "on", "":
		return true
	case "auto":
		break
	default:
		return false
	}

	if modRoot := findModuleRoot(base.Cwd()); modRoot == "" {
		// GO111模块为“自动”，我们找不到模块根目录。
		// 保持GOPATH模式。
		return false
	} else if search.InDir(modRoot, os.TempDir()) == "." {
		// 如果创建/tmp/go。mod for experiment，
		// 那么任何在/tmp 
		// 下创建工作目录的测试都会找到它，并在不需要模块时获得模块。
		// 这是一件有点奇怪的事情，但当它发生时，它是相当神秘的。见戈朗。org/issue/26708。
		return false
	}
	return true
}

// 已启用报告模块是否已启用（或必须启用）。
// 如果模块已启用，但没有主模块，enabled返回true 
// 然后第一次使用模块信息将调用die 
// （通常通过MustModRoot）。
func Enabled() bool {
	Init()
	return modRoots != nil || cfg.ModulesEnabled
}

func VendorDir() string {
	return filepath.Join(MainModules.ModRoot(MainModules.mustGetSingleMainModule()), "vendor")
}

func inWorkspaceMode() bool {
	if !initialized {
		panic("inWorkspaceMode called before modload.Init called")
	}
	return workFilePath != ""
}

// HasModRoot报告主模块是否存在。
// HasModRoot可能返回false，即使Enabled返回true：例如，“get”
// 不需要主模块。
func HasModRoot() bool {
	Init()
	return modRoots != nil
}

// MustHaveModRoot检查主模块是否存在，
// 并调用base。如果没有主模块，请输入Fatalf。
func MustHaveModRoot() {
	Init()
	if !HasModRoot() {
		die()
	}
}

// ModFilePath返回将用于go的路径。mod 
// 文件，如果处于模块模式。ModFilePath调用base。Fatalf如果没有主
// 模块，即使设置了-modfile。
func ModFilePath() string {
	MustHaveModRoot()
	return modFilePath(findModuleRoot(base.Cwd()))
}

func modFilePath(modRoot string) string {
	if cfg.ModFile != "" {
		return cfg.ModFile
	}
	return filepath.Join(modRoot, "go.mod")
}

func die() {
	if cfg.Getenv("GO111MODULE") == "off" {
		base.Fatalf("go: modules disabled by GO111MODULE=off; see 'go help modules'")
	}
	if inWorkspaceMode() {
		base.Fatalf("go: no modules were found in the current workspace; see 'go help work'")
	}
	if dir, name := findAltConfig(base.Cwd()); dir != "" {
		rel, err := filepath.Rel(base.Cwd(), dir)
		if err != nil {
			rel = dir
		}
		cdCmd := ""
		if rel != "." {
			cdCmd = fmt.Sprintf("cd %s && ", rel)
		}
		base.Fatalf("go: cannot find main module, but found %s in %s\n\tto create a module there, run:\n\t%sgo mod init", name, dir, cdCmd)
	}
	base.Fatalf("go: %v", ErrNoModRoot)
}

var ErrNoModRoot = errors.New("go.mod file not found in current directory or any parent directory; see 'go help modules'")

type goModDirtyError struct{}

func (goModDirtyError) Error() string {
	if cfg.BuildModExplicit {
		return fmt.Sprintf("updates to go.mod needed, disabled by -mod=%v; to update it:\n\tgo mod tidy", cfg.BuildMod)
	}
	if cfg.BuildModReason != "" {
		return fmt.Sprintf("updates to go.mod needed, disabled by -mod=%s\n\t(%s)\n\tto update it:\n\tgo mod tidy", cfg.BuildMod, cfg.BuildModReason)
	}
	return "updates to go.mod needed; to update it:\n\tgo mod tidy"
}

var errGoModDirty error = goModDirtyError{}

func loadWorkFile(path string) (goVersion string, modRoots []string, replaces []*modfile.Replace, err error) {
	workDir := filepath.Dir(path)
	wf, err := ReadWorkFile(path)
	if err != nil {
		return "", nil, nil, err
	}
	if wf.Go != nil {
		goVersion = wf.Go.Version
	}
	seen := map[string]bool{}
	for _, d := range wf.Use {
		modRoot := d.Path
		if !filepath.IsAbs(modRoot) {
			modRoot = filepath.Join(workDir, modRoot)
		}

		if seen[modRoot] {
			return "", nil, nil, fmt.Errorf("path %s appears multiple times in workspace", modRoot)
		}
		seen[modRoot] = true
		modRoots = append(modRoots, modRoot)
	}

	return goVersion, modRoots, wf.Replace, nil
}

// ReadWorkFile读取并解析go。指定路径下的工作文件。
func ReadWorkFile(path string) (*modfile.WorkFile, error) {
	workData, err := ioutil.ReadFile(path)
	if err != nil {
		return nil, err
	}

	return modfile.ParseWork(path, workData, nil)
}

// WriteWorkFile清除并写出go。将工作文件复制到给定路径。
func WriteWorkFile(path string, wf *modfile.WorkFile) error {
	wf.SortBlocks()
	wf.Cleanup()
	out := modfile.Format(wf.Syntax)

	return ioutil.WriteFile(path, out, 0666)
}

// UpdateWorkFile更新go中目录指令的注释。使用
// 文件包含相关模块路径。
func UpdateWorkFile(wf *modfile.WorkFile) {
	missingModulePaths := map[string]string{} // 文件->ABPATH modroot中列出的模块目录

	for _, d := range wf.Use {
		if d.Path == "" {
			continue // d标记为删除。
		}
		modRoot := d.Path
		if d.ModulePath == "" {
			missingModulePaths[d.Path] = modRoot
		}
	}

	// 清理并注释目录。
	// TODO（matloob）：更新x/mod以实际添加模块路径。
	for moddir, absmodroot := range missingModulePaths {
		_, f, err := ReadModFile(filepath.Join(absmodroot, "go.mod"), nil)
		if err != nil {
			continue // 如果加载模块，将报告错误。
		}
		wf.AddUse(moddir, f.Module.Mod.Path)
	}
}

// LoadModFile设置目标，如果有主模块，则从其开始解析初始
// 构建列表。mod文件。
// 
// LoadModFile可能会在内存中进行更改，例如添加go指令和
// 确保要求一致。调用方负责通过调用LoadPackages或ListModules 
// （除非设置了ExplicitWriteGoMod）或直接调用WriteGoMod，确保将这些更改写入磁盘。
// 
// 作为副作用，LoadModFile可能会更改cfg。如果未明确设置
// /-mod，则将BuildMod设置为“卖方”，并应启用自动卖方。
// 
// 如果已调用LoadModFile或CreateModFile，LoadModFile将返回
// 现有的内存需求（而不是从磁盘重新读取它们）。
// 
// LoadModFile检查模块图的根与每个
// 其他的一致性，但与LoadModGraph不同的是，它不加载完整的模块图，也不检查
// 它的全局一致性。modload包之外的大多数调用方都应该使用LoadModGraph。
func LoadModFile(ctx context.Context) *Requirements {
	if requirements != nil {
		return requirements
	}

	Init()
	var (
		workFileGoVersion string
		workFileReplaces  []*modfile.Replace
	)
	if inWorkspaceMode() {
		var err error
		workFileGoVersion, modRoots, workFileReplaces, err = loadWorkFile(workFilePath)
		if err != nil {
			base.Fatalf("reading go.work: %v", err)
		}
		for _, modRoot := range modRoots {
			sumFile := strings.TrimSuffix(modFilePath(modRoot), ".mod") + ".sum"
			modfetch.WorkspaceGoSumFiles = append(modfetch.WorkspaceGoSumFiles, sumFile)
		}
		modfetch.GoSumFile = workFilePath + ".sum"
	} else if modRoots == nil {
		// 我们处于模块模式，但不在模块内。
		// 
		// 像“go build”、“go run”、“go list”这样的命令无法执行。mod file to 
		// 读取或写入。他们需要找到并下载大量模块的最新版本
		// 无法保存版本
		// 信息。我们可以慢慢取得成功（但不能重复），但这通常不是一次好的经历。
		// 
		// 相反，我们禁止解析除std和
		// cmd以外的模块的导入路径。用户仍然可以生成使用指定的包。go文件在
		// 命令行上，但是如果这些文件导入了std.
		// 之外的任何内容，它们会看到错误。
		// 
		// 这可以通过调用AllowMissingModuleImports来覆盖。
		// 例如，“go-get”就是这样做的，因为它需要解析路径。
		// 
		// 见戈朗。org/issue/32027。
	} else {
		modfetch.GoSumFile = strings.TrimSuffix(modFilePath(modRoots[0]), ".mod") + ".sum"
	}
	if len(modRoots) == 0 {
		// TODO（#49228）：与其创建一个带有空modroot的假模块，不如
		// make main modules。Len（）==0表示我们处于模块模式，但不在
		// 任何模块内。
		mainModule := module.Version{Path: "command-line-arguments"}
		MainModules = makeMainModules([]module.Version{mainModule}, []string{""}, []*modfile.File{nil}, []*modFileIndex{nil}, "", nil)
		goVersion := LatestGoVersion()
		rawGoVersion.Store(mainModule, goVersion)
		pruning := pruningForGoVersion(goVersion)
		if inWorkspaceMode() {
			pruning = workspace
		}
		requirements = newRequirements(pruning, nil, nil)
		return requirements
	}

	var modFiles []*modfile.File
	var mainModules []module.Version
	var indices []*modFileIndex
	for _, modroot := range modRoots {
		gomod := modFilePath(modroot)
		var fixed bool
		data, f, err := ReadModFile(gomod, fixVersion(ctx, &fixed))
		if err != nil {
			base.Fatalf("go: %v", err)
		}

		modFiles = append(modFiles, f)
		mainModule := f.Module.Mod
		mainModules = append(mainModules, mainModule)
		indices = append(indices, indexModFile(data, f, mainModule, fixed))

		if err := module.CheckImportPath(f.Module.Mod.Path); err != nil {
			if pathErr, ok := err.(*module.InvalidPathError); ok {
				pathErr.Kind = "module"
			}
			base.Fatalf("go: %v", err)
		}
	}

	MainModules = makeMainModules(mainModules, modRoots, modFiles, indices, workFileGoVersion, workFileReplaces)
	setDefaultBuildMod() // 可能启用自动销售
	rs := requirementsFromModFiles(ctx, modFiles)

	if inWorkspaceMode() {
		// 我们不需要为供应商做任何事情，也不需要更新mod文件，以便
		// 尽早返回。
		requirements = rs
		return rs
	}

	mainModule := MainModules.mustGetSingleMainModule()

	if cfg.BuildMod == "vendor" {
		readVendorList(mainModule)
		index := MainModules.Index(mainModule)
		modFile := MainModules.ModFile(mainModule)
		checkVendorConsistency(index, modFile)
		rs.initVendor(vendorList)
	}

	if rs.hasRedundantRoot() {
		// 如果任何模块路径在根中出现多次，我们知道
		// 将继续。mod文件需要更新，即使我们还没有加载任何
		// 可传递依赖项。
		var err error
		rs, err = updateRoots(ctx, rs.direct, rs, nil, nil, false)
		if err != nil {
			base.Fatalf("go: %v", err)
		}
	}

	if MainModules.Index(mainModule).goVersionV == "" && rs.pruning != workspace {
		// TODO（#45551）：做一些更有原则的事情，而不是检查
		// cfg。请直接在此处输入您的姓名。
		if cfg.BuildMod == "mod" && cfg.CmdName != "mod graph" && cfg.CmdName != "mod why" {
			addGoStmt(MainModules.ModFile(mainModule), mainModule, LatestGoVersion())

			// 我们需要在go中添加一个“go”版本。mod file，但我们必须假设
			// 其现有内容与Go 1.11和1.16之间的内容相匹配。
			// Go 1.11到1.16不支持图形修剪，但最新的Go 
			// 版本使用了一个经过修剪的模块图形-因此我们需要将
			// 要求转换为支持修剪。
			var err error
			rs, err = convertPruning(ctx, rs, pruned)
			if err != nil {
				base.Fatalf("go: %v", err)
			}
		} else {
			rawGoVersion.Store(mainModule, modFileGoVersion(MainModules.ModFile(mainModule)))
		}
	}

	requirements = rs
	return requirements
}

// CreateModFile通过创建go来初始化新模块。mod文件。
// 
// 如果modPath为空，CreateModFile将尝试从GOPATH中的
// 目录位置推断路径。
// 
// 如果存在供应商配置文件，CreateModFile将尝试将其转换为go。国防部指令。生成的生成列表可能不是
// 与传统配置完全相同（例如，我们无法从同一模块获得多个版本的
// 软件包）。
func CreateModFile(ctx context.Context, modPath string) {
	modRoot := base.Cwd()
	modRoots = []string{modRoot}
	Init()
	modFilePath := modFilePath(modRoot)
	if _, err := fsys.Stat(modFilePath); err == nil {
		base.Fatalf("go: %s already exists", modFilePath)
	}

	if modPath == "" {
		var err error
		modPath, err = findModulePath(modRoot)
		if err != nil {
			base.Fatalf("go: %v", err)
		}
	} else if err := module.CheckImportPath(modPath); err != nil {
		if pathErr, ok := err.(*module.InvalidPathError); ok {
			pathErr.Kind = "module"
			// 与构建相同。IsLocalPath（）
			if pathErr.Path == "." || pathErr.Path == ".." ||
				strings.HasPrefix(pathErr.Path, "./") || strings.HasPrefix(pathErr.Path, "../") {
				pathErr.Err = errors.New("is a local import path")
			}
		}
		base.Fatalf("go: %v", err)
	} else if _, _, ok := module.SplitPathVersion(modPath); !ok {
		if strings.HasPrefix(modPath, "gopkg.in/") {
			invalidMajorVersionMsg := fmt.Errorf("module paths beginning with gopkg.in/ must always have a major version suffix in the form of .vN:\n\tgo mod init %s", suggestGopkgIn(modPath))
			base.Fatalf(`go: invalid module path "%v": %v`, modPath, invalidMajorVersionMsg)
		}
		invalidMajorVersionMsg := fmt.Errorf("major version suffixes must be in the form of /vN and are only allowed for v2 or later:\n\tgo mod init %s", suggestModulePath(modPath))
		base.Fatalf(`go: invalid module path "%v": %v`, modPath, invalidMajorVersionMsg)
	}

	fmt.Fprintf(os.Stderr, "go: creating new go.mod: module %s\n", modPath)
	modFile := new(modfile.File)
	modFile.AddModuleStmt(modPath)
	MainModules = makeMainModules([]module.Version{modFile.Module.Mod}, []string{modRoot}, []*modfile.File{modFile}, []*modFileIndex{nil}, "", nil)
	addGoStmt(modFile, modFile.Module.Mod, LatestGoVersion()) // 在转换模块需求之前添加go指令。

	convertedFrom, err := convertLegacyConfig(modFile, modRoot)
	if convertedFrom != "" {
		fmt.Fprintf(os.Stderr, "go: copying requirements from %s\n", base.ShortPath(convertedFrom))
	}
	if err != nil {
		base.Fatalf("go: %v", err)
	}

	rs := requirementsFromModFiles(ctx, []*modfile.File{modFile})
	rs, err = updateRoots(ctx, rs.direct, rs, nil, nil, false)
	if err != nil {
		base.Fatalf("go: %v", err)
	}
	requirements = rs
	if err := commitRequirements(ctx); err != nil {
		base.Fatalf("go: %v", err)
	}

	// 除非项目是空的，否则建议运行“go mod tidy”。即使我们导入了上面所有正确的需求，我们也可能遗漏了一些总数，因此-mod=readonly中的下一个build命令可能会失败。
	// 
	// 我们寻找非隐藏的。转到文件或子目录以确定
	// 这是一个现有项目。在树上寻找包裹会更准确，但可能需要更长的时间。
	empty := true
	files, _ := os.ReadDir(modRoot)
	for _, f := range files {
		name := f.Name()
		if strings.HasPrefix(name, ".") || strings.HasPrefix(name, "_") {
			continue
		}
		if strings.HasSuffix(name, ".go") || f.IsDir() {
			empty = false
			break
		}
	}
	if !empty {
		fmt.Fprintf(os.Stderr, "go: to add module requirements and sums:\n\tgo mod tidy\n")
	}
}

// CreateWorkFile通过创建go来初始化新的工作区。工作文件。
func CreateWorkFile(ctx context.Context, workFile string, modDirs []string) {
	if _, err := fsys.Stat(workFile); err == nil {
		base.Fatalf("go: %s already exists", workFile)
	}

	goV := LatestGoVersion() // 默认使用当前Go版本
	workF := new(modfile.WorkFile)
	workF.Syntax = new(modfile.FileSyntax)
	workF.AddGoStmt(goV)

	for _, dir := range modDirs {
		_, f, err := ReadModFile(filepath.Join(dir, "go.mod"), nil)
		if err != nil {
			if os.IsNotExist(err) {
				base.Fatalf("go: creating workspace file: no go.mod file exists in directory %v", dir)
			}
			base.Fatalf("go: error parsing go.mod in directory %s: %v", dir, err)
		}
		workF.AddUse(ToDirectoryPath(dir), f.Module.Mod.Path)
	}

	UpdateWorkFile(workF)
	WriteWorkFile(workFile, workF)
}

// 修复版本返回modfile。VersionFixer是使用Query函数实现的。
// 
// 它将提交散列和分支名称解析为版本，
// 规范化早期vgo草稿中出现的版本，
// 并且对已经出现的规范化版本不做任何处理。
// 
// VersionFixer在返回非规范版本时设置“fixed”。
func fixVersion(ctx context.Context, fixed *bool) modfile.VersionFixer {
	return func(path, vers string) (resolved string, err error) {
		defer func() {
			if err == nil && resolved != vers {
				*fixed = true
			}
		}()

		// 特殊情况：删除旧的-gopkgin-hack。
		if strings.HasPrefix(path, "gopkg.in/") && strings.Contains(vers, "-gopkgin-") {
			vers = vers[strings.Index(vers, "-gopkgin-")+len("-gopkgin-"):]
		}

		// 在每个
		// 模块上推测性地调用fixVersion，每个go的版本对。mod文件。
		// 如果看起来没有问题，请避免查询。
		_, pathMajor, ok := module.SplitPathVersion(path)
		if !ok {
			return "", &module.ModuleError{
				Path: path,
				Err: &module.InvalidVersionError{
					Version: vers,
					Err:     fmt.Errorf("malformed module path %q", path),
				},
			}
		}
		if vers != "" && module.CanonicalVersion(vers) == vers {
			if err := module.CheckPathMajor(vers, pathMajor); err != nil {
				return "", module.VersionError(module.Version{Path: path, Version: vers}, err)
			}
			return vers, nil
		}

		info, err := Query(ctx, path, vers, "", nil)
		if err != nil {
			return "", err
		}
		return info.Version, nil
	}
}

// AllowMissingModuleImports允许在没有模块根的情况下将导入路径解析为模块
// 。通常情况下，这是被禁止的，因为它的速度很慢，而且无法使结果重现，但是一些命令，如“go get”，应该可以做到这一点。
// 
// 此函数影响默认的cfg。BuildMod在模块外部时，
// 因此只能在Init之前调用它。
func AllowMissingModuleImports() {
	if initialized {
		panic("AllowMissingModuleImports after Init")
	}
	allowMissingModuleImports = true
}

// makeMainModules根据给定的主模块创建一个MainModuleSet和相关变量。
func makeMainModules(ms []module.Version, rootDirs []string, modFiles []*modfile.File, indices []*modFileIndex, workFileGoVersion string, workFileReplaces []*modfile.Replace) *MainModuleSet {
	for _, m := range ms {
		if m.Version != "" {
			panic("mainModulesCalled with module.Version with non empty Version field: " + fmt.Sprintf("%#v", m))
		}
	}
	modRootContainingCWD := findModuleRoot(base.Cwd())
	mainModules := &MainModuleSet{
		versions:           ms[:len(ms):len(ms)],
		inGorootSrc:        map[module.Version]bool{},
		pathPrefix:         map[module.Version]string{},
		modRoot:            map[module.Version]string{},
		modFiles:           map[module.Version]*modfile.File{},
		indices:            map[module.Version]*modFileIndex{},
		workFileGoVersion:  workFileGoVersion,
		workFileReplaceMap: toReplaceMap(workFileReplaces),
		highestReplaced:    map[string]string{},
	}
	mainModulePaths := make(map[string]bool)
	for _, m := range ms {
		mainModulePaths[m.Path] = true
	}
	replacedByWorkFile := make(map[string]bool)
	replacements := make(map[module.Version]module.Version)
	for _, r := range workFileReplaces {
		if mainModulePaths[r.Old.Path] && r.Old.Version == "" {
			base.Errorf("go: workspace module %v is replaced at all versions in the go.work file. To fix, remove the replacement from the go.work file or specify the version at which to replace the module.", r.Old.Path)
		}
		replacedByWorkFile[r.Old.Path] = true
		v, ok := mainModules.highestReplaced[r.Old.Path]
		if !ok || semver.Compare(r.Old.Version, v) > 0 {
			mainModules.highestReplaced[r.Old.Path] = r.Old.Version
		}
		replacements[r.Old] = r.New
	}
	for i, m := range ms {
		mainModules.pathPrefix[m] = m.Path
		mainModules.modRoot[m] = rootDirs[i]
		mainModules.modFiles[m] = modFiles[i]
		mainModules.indices[m] = indices[i]

		if mainModules.modRoot[m] == modRootContainingCWD {
			mainModules.modContainingCWD = m
		}

		if rel := search.InDir(rootDirs[i], cfg.GOROOTsrc); rel != "" {
			mainModules.inGorootSrc[m] = true
			if m.Path == "std" {
				// GOROOT/src中的“std”模块是Go标准库。与其他
				// 模块不同，“std”模块中的包没有导入路径前缀。
				// 
				// GOROOT/src之外名为“std”的模块不接受这种特殊的
				// 处理，因此可以运行“go test”在
				// 的其他版本中，使用修改后的包
				// 和普通标准库的组合测试单个包。
				// （请参阅https:
				mainModules.pathPrefix[m] = ""
			}
		}

		if modFiles[i] != nil {
			curModuleReplaces := make(map[module.Version]bool)
			for _, r := range modFiles[i].Replace {
				if replacedByWorkFile[r.Old.Path] {
					continue
				}
				var newV module.Version = r.New
				if WorkFilePath() != "" && newV.Version == "" && !filepath.IsAbs(newV.Path) {
					// 因为我们在一个工作区中，我们可能正在从多个go.mod文件加载替换。这些替换中的相对路径是相对于go.mod文件的
					// 而不是相对于工作区的，所以同一个字符串
					// 可能指两个不同的路径，不同的字符串可能指的是
					// 相同的路径。）路径将它们全部转化为绝对值。
					// 
					// （我们也可以在工作区之外执行此操作，但这意味着错误字符串中的替换路径与go.mod文件中的替换路径不必要地不同。）
					newV.Path = filepath.Join(rootDirs[i], newV.Path)
				}
				if prev, ok := replacements[r.Old]; ok && !curModuleReplaces[r.Old] && prev != newV {
					base.Fatalf("go: conflicting replacements for %v:\n\t%v\n\t%v\nuse \"go work edit -replace %v=[override]\" to resolve", r.Old, prev, newV, r.Old)
				}
				curModuleReplaces[r.Old] = true
				replacements[r.Old] = newV

				v, ok := mainModules.highestReplaced[r.Old.Path]
				if !ok || semver.Compare(r.Old.Version, v) > 0 {
					mainModules.highestReplaced[r.Old.Path] = r.Old.Version
				}
			}
		}
	}
	return mainModules
}

// requirementsFromModFiles返回全局modFile中未排除的需求集。
func requirementsFromModFiles(ctx context.Context, modFiles []*modfile.File) *Requirements {
	var roots []module.Version
	direct := map[string]bool{}
	var pruning modPruning
	if inWorkspaceMode() {
		pruning = workspace
		roots = make([]module.Version, len(MainModules.Versions()))
		copy(roots, MainModules.Versions())
	} else {
		pruning = pruningForGoVersion(MainModules.GoVersion())
		if len(modFiles) != 1 {
			panic(fmt.Errorf("requirementsFromModFiles called with %v modfiles outside workspace mode", len(modFiles)))
		}
		modFile := modFiles[0]
		roots = make([]module.Version, 0, len(modFile.Require))
		mm := MainModules.mustGetSingleMainModule()
		for _, r := range modFile.Require {
			if index := MainModules.Index(mm); index != nil && index.exclude[r.Mod] {
				if cfg.BuildMod == "mod" {
					fmt.Fprintf(os.Stderr, "go: dropping requirement on excluded version %s %s\n", r.Mod.Path, r.Mod.Version)
				} else {
					fmt.Fprintf(os.Stderr, "go: ignoring requirement on excluded version %s %s\n", r.Mod.Path, r.Mod.Version)
				}
				continue
			}

			roots = append(roots, r.Mod)
			if !r.Indirect {
				direct[r.Mod.Path] = true
			}
		}
	}
	module.Sort(roots)
	rs := newRequirements(pruning, roots, direct)
	return rs
}

// setDefaultBuildMod为cfg设置默认值。如果未提供-mod标志
// 则生成mod。setDefaultBuildMod可能会被调用多次。
func setDefaultBuildMod() {
	if cfg.BuildModExplicit {
		if inWorkspaceMode() && cfg.BuildMod != "readonly" {
			base.Fatalf("go: -mod may only be set to readonly when in workspace mode, but it is set to %q"+
				"\n\tRemove the -mod flag to use the default readonly value,"+
				"\n\tor set GOWORK=off to disable workspace mode.", cfg.BuildMod)
		}
		// 不要重写显式“-mod=”参数。
		return
	}

	// TODO（#40775）：命令应该以模块模式作为选项传递给modload函数，而不是依赖基于命令名的隐式设置
	// 。
	switch cfg.CmdName {
	case "get", "mod download", "mod init", "mod tidy", "work sync":
		// 这些命令用于更新go。mod和go。总和
		cfg.BuildMod = "mod"
		return
	case "mod graph", "mod verify", "mod why":
		// 这些命令不应更新go。mod或go。求和，但它们应该是
		// 能够获取不在go中的模块。如果
		// go，则不应报告错误。mod不一致。它们对调试很有用，并且需要
		// 才能在有缺陷的情况下工作。
		cfg.BuildMod = "mod"
		return
	case "mod vendor":
		cfg.BuildMod = "readonly"
		return
	}
	if modRoots == nil {
		if allowMissingModuleImports {
			cfg.BuildMod = "mod"
		} else {
			cfg.BuildMod = "readonly"
		}
		return
	}

	if len(modRoots) == 1 {
		index := MainModules.GetSingleIndexOrNil()
		if fi, err := fsys.Stat(filepath.Join(modRoots[0], "vendor")); err == nil && fi.IsDir() {
			modGo := "unspecified"
			if index != nil && index.goVersionV != "" {
				if semver.Compare(index.goVersionV, "v1.14") >= 0 {
					// Go版本至少为1.14，并且存在供应商目录。默认情况下，
					// Set-mod=vendor。
					cfg.BuildMod = "vendor"
					cfg.BuildModReason = "Go version in go.mod is at least 1.14 and vendor directory exists."
					return
				} else {
					modGo = index.goVersionV[1:]
				}
			}

			// 由于存在供应商目录，我们应该记录为什么不使用它。
			// 此消息通常不会显示，但可能会出现导入错误。
			cfg.BuildModReason = fmt.Sprintf("Go version in go.mod is %s, so vendor directory was not used.", modGo)
		}
	}

	cfg.BuildMod = "readonly"
}

func mustHaveCompleteRequirements() bool {
	return cfg.BuildMod != "mod" && !inWorkspaceMode()
}

// convertLegacyConfig从传统供应商处导入模块需求
// 配置文件（如果存在）。
func convertLegacyConfig(modFile *modfile.File, modRoot string) (from string, err error) {
	noneSelected := func(path string) (version string) { return "none" }
	queryPackage := func(path, rev string) (module.Version, error) {
		pkgMods, modOnly, err := QueryPattern(context.Background(), path, rev, noneSelected, nil)
		if err != nil {
			return module.Version{}, err
		}
		if len(pkgMods) > 0 {
			return pkgMods[0].Mod, nil
		}
		return modOnly.Mod, nil
	}
	for _, name := range altConfigs {
		cfg := filepath.Join(modRoot, name)
		data, err := os.ReadFile(cfg)
		if err == nil {
			convert := modconv.Converters[name]
			if convert == nil {
				return "", nil
			}
			cfg = filepath.ToSlash(cfg)
			err := modconv.ConvertLegacyConfig(modFile, cfg, data, queryPackage)
			return name, err
		}
	}
	return "", nil
}

// addGoStmt在go中添加go指令。mod file，如果它还没有
// 包括一个。添加的“go”版本（如果有）是该工具链支持的最新版本
// 。
func addGoStmt(modFile *modfile.File, mod module.Version, v string) {
	if modFile.Go != nil && modFile.Go.Version != "" {
		return
	}
	if err := modFile.AddGoStmt(v); err != nil {
		base.Fatalf("go: internal error: %v", err)
	}
	rawGoVersion.Store(mod, v)
}

// LatestGoVersion返回此工具链支持的Go语言的最新版本，如“1.17”。
func LatestGoVersion() string {
	tags := build.Default.ReleaseTags
	version := tags[len(tags)-1]
	if !strings.HasPrefix(version, "go") || !modfile.GoVersionRE.MatchString(version[2:]) {
		base.Fatalf("go: internal error: unrecognized default version %q", version)
	}
	return version[2:]
}

// 如果v是第一个主要版本（1.0）或不是受支持的
// 或v之前的主要版本。
// Go版本，Priorgoverion将返回紧跟在v、
func priorGoVersion(v string) string {
	vTag := "go" + v
	tags := build.Default.ReleaseTags
	for i, tag := range tags {
		if tag == vTag {
			if i == 0 {
				return v
			}

			version := tags[i-1]
			if !strings.HasPrefix(version, "go") || !modfile.GoVersionRE.MatchString(version[2:]) {
				base.Fatalf("go: internal error: unrecognized version %q", version)
			}
			return version[2:]
		}
	}
	return v
}

var altConfigs = []string{
	"Gopkg.lock",

	"GLOCKFILE",
	"Godeps/Godeps.json",
	"dependencies.tsv",
	"glide.lock",
	"vendor.conf",
	"vendor.yml",
	"vendor/manifest",
	"vendor/vendor.json",

	".git/config",
}

func findModuleRoot(dir string) (roots string) {
	if dir == "" {
		panic("dir not set")
	}
	dir = filepath.Clean(dir)

	// 寻找封闭围棋。摩登派青年
	for {
		if fi, err := fsys.Stat(filepath.Join(dir, "go.mod")); err == nil && !fi.IsDir() {
			return dir
		}
		d := filepath.Dir(dir)
		if d == dir {
			break
		}
		dir = d
	}
	return ""
}

func findWorkspaceFile(dir string) (root string) {
	if dir == "" {
		panic("dir not set")
	}
	dir = filepath.Clean(dir)

	// 寻找封闭围棋。摩登派青年
	for {
		f := filepath.Join(dir, "go.work")
		if fi, err := fsys.Stat(f); err == nil && !fi.IsDir() {
			return f
		}
		d := filepath.Dir(dir)
		if d == dir {
			break
		}
		if d == cfg.GOROOT {
			// 作为一种特殊情况，不要越过戈鲁特寻找出路。工作文件。
			// go中内置的标准库和命令始终使用供应商的
			// 依赖项，因此避免使用最可能不相关的go。工作文件。
			return ""
		}
		dir = d
	}
	return ""
}

func findAltConfig(dir string) (root, name string) {
	if dir == "" {
		panic("dir not set")
	}
	dir = filepath.Clean(dir)
	if rel := search.InDir(dir, cfg.BuildContext.GOROOT); rel != "" {
		// 不要建议从$GOROOT/创建模块。git/config 
		// 或在$GOROOT的任何父项中找到的配置文件（请参见#34191）。
		return "", ""
	}
	for {
		for _, name := range altConfigs {
			if fi, err := fsys.Stat(filepath.Join(dir, name)); err == nil && !fi.IsDir() {
				return dir, name
			}
		}
		d := filepath.Dir(dir)
		if d == dir {
			break
		}
		dir = d
	}
	return "", ""
}

func findModulePath(dir string) (string, error) {
	// TODO（bcmills）：一旦我们找到了一个合理的模块路径，我们应该查询版本控制（如果可用），以验证它是否与最新标记的主要
	// 版本匹配。
	// 请参阅https:
	// https:

	// 有关导入注释，
	// 首先在顶级目录中，然后在子目录中。
	list, _ := os.ReadDir(dir)
	for _, info := range list {
		if info.Type().IsRegular() && strings.HasSuffix(info.Name(), ".go") {
			if com := findImportComment(filepath.Join(dir, info.Name())); com != "" {
				return com, nil
			}
		}
	}
	for _, info1 := range list {
		if info1.IsDir() {
			files, _ := os.ReadDir(filepath.Join(dir, info1.Name()))
			for _, info2 := range files {
				if info2.Type().IsRegular() && strings.HasSuffix(info2.Name(), ".go") {
					if com := findImportComment(filepath.Join(dir, info1.Name(), info2.Name())); com != "" {
						return path.Dir(com), nil
					}
				}
			}
		}
	}

	// 寻找Godeps。json声明导入路径。
	data, _ := os.ReadFile(filepath.Join(dir, "Godeps/Godeps.json"))
	var cfg1 struct{ ImportPath string }
	json.Unmarshal(data, &cfg1)
	if cfg1.ImportPath != "" {
		return cfg1.ImportPath, nil
	}

	// 寻找供应商。json声明导入路径。
	data, _ = os.ReadFile(filepath.Join(dir, "vendor/vendor.json"))
	var cfg2 struct{ RootPath string }
	json.Unmarshal(data, &cfg2)
	if cfg2.RootPath != "" {
		return cfg2.RootPath, nil
	}

	// 在GOPATH中查找路径。
	var badPathErr error
	for _, gpdir := range filepath.SplitList(cfg.BuildContext.GOPATH) {
		if gpdir == "" {
			continue
		}
		if rel := search.InDir(dir, filepath.Join(gpdir, "src")); rel != "" && rel != "." {
			path := filepath.ToSlash(rel)
			// gorelease将提醒发布模块的用户修复路径。
			if err := module.CheckImportPath(path); err != nil {
				badPathErr = err
				break
			}
			return path, nil
		}
	}

	reason := "outside GOPATH, module path must be specified"
	if badPathErr != nil {
		// 如果模块位于GOPATH中，则返回不同的错误消息，但
		// 上述确定的模块路径将是无效路径。
		reason = fmt.Sprintf("bad module path inferred from directory in GOPATH: %v", badPathErr)
	}
	msg := `cannot determine module path for source directory %s (%s)

Example usage:
	'go mod init example.com/m' to initialize a v0 or v1 module
	'go mod init example.com/m/v2' to initialize a v2 module

Run 'go help mod init' for more information.
`
	return "", fmt.Errorf(msg, dir, reason)
}

var (
	importCommentRE = lazyregexp.New(`(?m)^package[ \t]+[^ \t\r\n/]+[ \t]+// /[\t]+导入[\t]+（\“[^”]+\”[\t]*\r？\n`）
)

func findImportComment(file string) string {
	data, err := os.ReadFile(file)
	if err != nil {
		return ""
	}
	m := importCommentRE.FindSubmatch(data)
	if m == nil {
		return ""
	}
	path, err := strconv.Unquote(string(m[1]))
	if err != nil {
		return ""
	}
	return path
}

// /WriteGoMod将当前构建列表写回go.mod。
func WriteGoMod(ctx context.Context) error {
	requirements = LoadModFile(ctx)
	return commitRequirements(ctx)
}

// 提交要求确保go.mod和go.sum与当前
// 要求保持一致。
// 
// /In“mod“模式下，CommitteRequirements将更改写入“只读”和“供应商”中的go.mod和go.sum.
// 
// ”“如果
// go.mod或go.sum在语义上已过期，则commitRequirements将返回错误。
// 
// 在工作区模式下，commitRequirements仅将更改写入go.work.sum。
func commitRequirements(ctx context.Context) (err error) {
	if inWorkspaceMode() {
		// go.mod文件不会在工作区模式下更新，但我们仍希望
		// 更新go.work.sum文件。
		return modfetch.WriteGoSum(keepSums(ctx, loaded, requirements, addBuildListZipSums), mustHaveCompleteRequirements())
	}
	if MainModules.Len() != 1 || MainModules.ModRoot(MainModules.Versions()[0]) == "" {
		// 我们不在模块中，所以我们没有地方写围棋。mod文件。
		return nil
	}
	mainModule := MainModules.mustGetSingleMainModule()
	modFile := MainModules.ModFile(mainModule)
	if modFile == nil {
		// 命令行参数没有。要写入的mod文件。
		return nil
	}
	modFilePath := modFilePath(MainModules.ModRoot(mainModule))

	var list []*modfile.Require
	for _, m := range requirements.rootModules {
		list = append(list, &modfile.Require{
			Mod:      m,
			Indirect: !requirements.direct[m.Path],
		})
	}
	if modFile.Go == nil || modFile.Go.Version == "" {
		modFile.AddGoStmt(modFileGoVersion(modFile))
	}
	if semver.Compare("v"+modFileGoVersion(modFile), separateIndirectVersionV) < 0 {
		modFile.SetRequire(list)
	} else {
		modFile.SetRequireSeparateIndirect(list)
	}
	modFile.Cleanup()

	index := MainModules.GetSingleIndexOrNil()
	dirty := index.modFileIsDirty(modFile)
	if dirty && cfg.BuildMod != "mod" {
		// 如果我们因为-mod=readonly即将失败，
		// 更愿意报告一次失败。一次肮脏的尝试。sum 
		return errGoModDirty
	}

	if !dirty && cfg.CmdName != "mod tidy" {
		// 开始吧。mod file的语义内容与
		// 之前相同（但不一定是相同的确切字节）。
		// 不要写go。mod，但是写下go。以防我们增加或减少总和。
		// /'go mod init'不应该写go。总数，因为它将是不完整的。
		if cfg.CmdName != "mod init" {
			if err := modfetch.WriteGoSum(keepSums(ctx, loaded, requirements, addBuildListZipSums), mustHaveCompleteRequirements()); err != nil {
				return err
			}
		}
		return nil
	}
	if _, ok := fsys.OverlayPath(modFilePath); ok {
		if dirty {
			return errors.New("updates to go.mod needed, but go.mod is part of the overlay specified with -overlay")
		}
		return nil
	}

	new, err := modFile.Format()
	if err != nil {
		return err
	}
	defer func() {
		// 此时此刻，我们决定行动起来。磁盘上的mod文件等于new。
		MainModules.SetIndex(mainModule, indexModFile(new, modFile, mainModule, false))

		// 更新开始。释放侧锁并刷新索引后求和。
		// /'go mod init'不应该写go。总数，因为它将是不完整的。
		if cfg.CmdName != "mod init" {
			if err == nil {
				err = modfetch.WriteGoSum(keepSums(ctx, loaded, requirements, addBuildListZipSums), mustHaveCompleteRequirements())
			}
		}
	}()

	// 尽最大努力获取侧锁，但不允许同时编辑之前版本的'go'命令。快走。mod file已经等于new，这可能是由于某些
	if unlock, err := modfetch.SideLock(); err == nil {
		defer unlock()
	}

	errNoChange := errors.New("no update needed")

	err = lockedfile.Transform(modFilePath, func(old []byte) ([]byte, error) {
		if bytes.Equal(old, new) {
			// 其他过程的结果。
			return nil, errNoChange
		}

		if index != nil && !bytes.Equal(old, index.data) {
			// 围棋的内容。mod文件已更改。理论上，我们可以将所有新模块添加到构建列表中，重新计算，并检查*我们的*构建列表中是否有任何模块被移植到了不同的版本，但这是
			// 为了边际效益做了大量工作。相反，命令失败：如果用户想要运行并发命令，他们需要从一个完整的、一致的模块定义开始。
			return nil, fmt.Errorf("existing contents have changed since last read")
		}

		return new, nil
	})

	if err != nil && err != errNoChange {
		return fmt.Errorf("updating go.mod: %w", err)
	}
	return nil
}

// keepSums返回一组模块（和go.mod文件项），其中
// 需要校验和才能重新加载同一组包
// 通过最近调用LoadPackages或ImportFromFiles加载，
// 包括任何go。重建MVS结果所需的mod文件
// 除了keepMods中每个模块的校验和之外。
func keepSums(ctx context.Context, ld *loader, rs *Requirements, which whichSums) map[module.Version]bool {
	// 完整模块图中的每个模块都会贡献其需求，
	// 因此，为了确保构建列表本身是可复制的，
	// 我们需要每次执行的总和。图中的mod（无论是否选择
	// 该版本）。
	keep := make(map[module.Version]bool)

	// 为构建列表中的模块添加条目，路径是加载包的路径的前缀。我们需要保留所有这些模块的总和——
	// 而不仅仅是包含实际软件包的模块——以便在下次加载软件包时排除
	// 模棱两可的导入错误。
	if ld != nil {
		for _, pkg := range ld.pkgs {
			// 我们检查包裹。摩登派青年路径在这里，而不是pkg。因为
			// 伪包“C”不在std中，但不由任何模块提供（并且
			// 不应强制加载整个模块图）。
			if pkg.testOf != nil || (pkg.mod.Path == "" && pkg.err == nil) || module.CheckImportPath(pkg.path) != nil {
				continue
			}

			if rs.pruning == pruned && pkg.mod.Path != "" {
				if v, ok := rs.rootSelected(pkg.mod.Path); ok && v == pkg.mod.Version {
					// pkg是从根模块加载的，因为主模块有
					// 一个经过修剪的模块图，我们不检查非根模块是否存在
					// 根中可以找到的包冲突。所以我们只需要
					// 可能包含pkg的根模块的校验和，而不是所有可能的模块。wen jian defg
					for prefix := pkg.path; prefix != "."; prefix = path.Dir(prefix) {
						if v, ok := rs.rootSelected(prefix); ok && v != "none" {
							m := module.Version{Path: prefix, Version: v}
							r := resolveReplacement(m)
							keep[r] = true
						}
					}
					continue
				}
			}

			mg, _ := rs.Graph(ctx)
			for prefix := pkg.path; prefix != "."; prefix = path.Dir(prefix) {
				if v := mg.Selected(prefix); v != "none" {
					m := module.Version{Path: prefix, Version: v}
					r := resolveReplacement(m)
					keep[r] = true
				}
			}
		}
	}

	if rs.graph.Load() == nil {
		// 保存根模块（或其替换）的总和，但不要为了查找和保留总和而导致加载图形的成本。
		for _, m := range rs.rootModules {
			r := resolveReplacement(m)
			keep[modkey(r)] = true
			if which == addBuildListZipSums {
				keep[r] = true
			}
		}
	} else {
		mg, _ := rs.Graph(ctx)
		mg.WalkBreadthFirst(func(m module.Version) {
			if _, ok := mg.RequiredBy(m); ok {
				// 符合m's go的要求。mod file出现在模块图中，
				// 因此它们与MVS结果相关，而不管m是否实际选中。
				r := resolveReplacement(m)
				keep[modkey(r)] = true
			}
		})

		if which == addBuildListZipSums {
			for _, m := range mg.BuildList() {
				r := resolveReplacement(m)
				keep[r] = true
			}
		}
	}

	return keep
}

type whichSums int8

const (
	loadedZipSumsOnly = whichSums(iota)
	addBuildListZipSums
)

// modKey返回模块。m的校验和的版本。mod 
// 文件存储在go中。求和文件。
func modkey(m module.Version) module.Version {
	return module.Version{Path: m.Path, Version: m.Version + "/go.mod"}
}

func suggestModulePath(path string) string {
	var m string

	i := len(path)
	for i > 0 && ('0' <= path[i-1] && path[i-1] <= '9' || path[i-1] == '.') {
		i--
	}
	url := path[:i]
	url = strings.TrimSuffix(url, "/v")
	url = strings.TrimSuffix(url, "/")

	f := func(c rune) bool {
		return c > '9' || c < '0'
	}
	s := strings.FieldsFunc(path[i:], f)
	if len(s) > 0 {
		m = s[0]
	}
	m = strings.TrimLeft(m, "0")
	if m == "" || m == "1" {
		return url + "/v2"
	}

	return url + "/v" + m
}

func suggestGopkgIn(path string) string {
	var m string
	i := len(path)
	for i > 0 && (('0' <= path[i-1] && path[i-1] <= '9') || (path[i-1] == '.')) {
		i--
	}
	url := path[:i]
	url = strings.TrimSuffix(url, ".v")
	url = strings.TrimSuffix(url, "/v")
	url = strings.TrimSuffix(url, "/")

	f := func(c rune) bool {
		return c > '9' || c < '0'
	}
	s := strings.FieldsFunc(path, f)
	if len(s) > 0 {
		m = s[0]
	}

	m = strings.TrimLeft(m, "0")

	if m == "" {
		return url + ".v1"
	}
	return url + ".v" + m
}
